package Flightadministration;

import Data.Aircraft;
import Data.Airline;
import Data.Airport;
import Data.Booking;
import Data.Flight;
import Data.FlightRealization;
import Data.Passenger;
import Data.Seat;
import Data.TypeOfAircraft;
import Report.ReportGenerator;
import java.util.Date;
import java.util.Vector;

/**
 * Schnittstelle zwischen Applikations-/DB-Logik und GUI
 * Verwaltung einzelner Abläufe
 *
 * @author Fabian Hoh
 * @author Philipp Armbruster
 *
 */


public interface Flightadministration extends java.rmi.Remote {


    /*      -       Create-Methoden     -       */

    
    /*
     * Einen Flughafen anlegen
     *
     * @param internationalId
     * @param portName 
     * @param portCity 
     * @param portCountry 
     * @return Ein Flughafen
     * @throws java.rmi.RemoteException
     */
    public Airport createAirport(String internationalId, String portName,
            String portCity, String portCountry) throws java.rmi.RemoteException;

    /**
     * Eine Fluglinie anlegen
     *
     * @param airName 
     * @return Eine Fluglinie
     * @throws java.rmi.RemoteException
     */
    public Airline createAirline(String airName) throws java.rmi.RemoteException;

    /**
     * Ein Flugzeug anlegen
     * 
     * @param craftName 
     * @return Ein Flugzeug
     * @throws java.rmi.RemoteException
     */
    public Aircraft createAircraft(String craftName, int airlineId, int typeOfAircraftId)
            throws java.rmi.RemoteException;

    /**
     * Einen Flugzeugtyp anlegen
     *
     * @param craftTypeName
     * @param seatArea
     * @return Ein Flugzeugtyp
     * @throws java.rmi.RemoteException
     */
    public TypeOfAircraft createTypeOfAircraft(String craftTypeName, int seatId)
            throws java.rmi.RemoteException;

    /**
     * Einen Flug anlegen
     *
     * @param timeOfDeparture
     * @param dayOfDeparture
     * @param timeOfArrival
     * @param dayOfArrival
     * @param departureAirportId
     * @param arrivalAirportId
     * @param airlineId
     * @return Geplanten Flug anlegen
     * @throws java.rmi.RemoteException
     */
    public Flight createFlight(String timeOfDeparture, String dayOfDeparture,
            String timeOfArrival, String dayOfArrival, String departureAirportId,
            String arrivalAirportId, int airlineId) throws java.rmi.RemoteException;

    /**
     * Eine Flugdurchführung anlegen
     *
     * @param dateOfDeparture
     * @param dateOfArrival
     * @param flightId
     * @param aircraftId
     * @return
     * @throws java.rmi.RemoteException
     */
    public FlightRealization createFlightRealization(Date dateOfDeparture,
            Date dateOfArrival, int flightId, int aircraftId) throws java.rmi.RemoteException;

    /**
     * Einen Passagier anlegen
     * 
     * @param firstName
     * @param lastName
     * @param street
     * @param postcode
     * @param city
     * @return Ein Passagier
     * @throws java.rmi.RemoteException
     */
    public Passenger createPassenger(String firstName, String lastName,
            String street, int postcode, String city) throws java.rmi.RemoteException;

    /**
     * Eine Sitzstrukturn anlegen
     *
     * @param seatsPerRow
     * @param numberOfRows
     * @return Eine Sitzstruktur
     * @throws java.rmi.RemoteException
     */
    public Seat createSeat(int seatsPerRow, int numberOfRows) throws java.rmi.RemoteException;

    /**
     * Eine Buchung anlegen
     *
     * @param passengerId
     * @param realizationId
     * @return Eine Buchung
     * @throws java.rmi.RemoteException
     */
    public Booking createBooking(int passengerId, int realizationId) throws java.rmi.RemoteException;

    /**
     * Einen Dauerauftrag für einen bestimmten Flug anlegen
     *
     * @param StartOfStandingOrder
     * @param EndOfStandingOrder
     * @param passengerId
     * @param realizationId
     * @return Eine / mehrere Buchungen
     * @throws java.rmi.RemoteException
     */
    public Vector<Booking> createStandingOrderForBookings(Date StartOfStandingOrder, Date EndOfStandingOrder, int passengerId, int realizationId)
            throws java.rmi.RemoteException;
    
    /**
     * CheckIn der entsprechenden Buchung durchführen und dabei dem Passagier einen festen Sitzplatz zuweisen.
     * @param bookingId
     * @return date (Datum des CheckIn), seat (Sitzplatz)
     * @throws java.rmi.RemoteException
     */
    public void checkIn(int bookingId, int realizationId) throws java.rmi.RemoteException;


    /*      -       Update-Methoden     -       */


     /**
     * Die Eigenschaften eines Flughafens ändern
     *
     * @param internationalId
     * @param portName
     * @param portCity
     * @param portCountry
     * @throws java.rmi.java.rmi.RemoteException
     */
    public void updateAirport(String internationalId, String portName, String portCity, String portCountry) throws java.rmi.RemoteException;

    /**
     * Die Eigenschaften einer Airline ändern
     *
     * @param airId
     * @param airName
     * @throws java.rmi.java.rmi.RemoteException
     */
    public void updateAirline(int airId, String airName) throws java.rmi.RemoteException;

     /**
     * Die Eigenschaften eines Flugzeuges ändern
     *
     * @param craftId
     * @param craftName
     * @param airlineId
     * @param typeOfAircraftId
     * @throws java.rmi.java.rmi.RemoteException
     */
    public void updateAircraft(int craftId, String craftName, int airlineId, int typeOfAircraftId) throws java.rmi.RemoteException;

     /**
     * Die Eigenschaften eines Flugzeugtyps ändern
     *
     * @param craftTypeId
     * @param craftTypeName
     * @param seatId
     * @throws java.rmi.java.rmi.RemoteException
     */
    public void updateTypeOfAircraft(int craftTypeId, String craftTypeName, int seatId) throws java.rmi.RemoteException;

    /**
     * Die Eigenschaften eines geplanten Fluges ändern
     *
     * @param flightId
     * @param timeOfDeparture
     * @param dayOfDeparture
     * @param timeOfArrival
     * @param dayOfArrival
     * @param departureAirportId
     * @param arrivalAirportId
     * @param airlineId
     * @throws java.rmi.RemoteException
     */
    public void updateFlight(int flightId, String timeOfDeparture, String dayOfDeparture,
            String timeOfArrival, String dayOfArrival, String departureAirportId, String arrivalAirportId, int airlineId)
            throws java.rmi.RemoteException;

    /**
     * Die Eigenschaften eines vor der Durchführung stehenden Fluges ändern
     *
     * @param realizationId
     * @param dateOfDeparture
     * @param dateOfArrival
     * @param flightId
     * @param aircraftId
     * @throws java.rmi.RemoteException
     */
    public void updateFlightRealization(int realizationId, Date dateOfDeparture, Date dateOfArrival, int flightId, int aircraftId)
            throws java.rmi.RemoteException;

     /**
     * Die Eigenschaften eines Passagiers ändern
     *
     * @param passengerId
     * @param firstName
     * @param lastName
     * @param street
     * @param postcode
     * @param city
     * @throws java.rmi.RemoteException
     */
    public void updatePassenger(int passengerId, String firstName, String lastName, String street, int postcode, String city)
            throws java.rmi.RemoteException;

    /**
     * Die Eigenschaften einer Sitzstruktur ändern
     *
     * @param seatId
     * @param seatsPerRow
     * @param numberOfRows
     * @throws java.rmi.RemoteException
     */
    public void updateSeat(int seatId, int seatsPerRow, int numberOfRows) throws java.rmi.RemoteException;

    /**
     * Die Eigenschaften einer Buchung ändern
     *
     * @param bookingId
     * @param passengerId
     * @param realizationId
     * @throws java.rmi.RemoteException
     */
    public void updateBooking(int bookingId, int passengerId, int realizationId) throws java.rmi.RemoteException;

    
    /*      -       Delete-Methoden     -       */

    
    /**
     * Löscht den ausgewählten Flughafen in der Datenbank
     *
     * @param internationalId
     * @param portName
     * @param portCity
     * @param portCountry
     * @throws java.rmi.RemoteException
     */
    public void deleteAirport(String internationalId, String portName, String portCity, String portCountry) throws java.rmi.RemoteException;

    /**
     * Löscht die ausgewählte Airline in der Datenbank
     *
     * @param airId
     * @param airName
     * @throws java.rmi.RemoteException
     */
    public void deleteAirline(int airId, String airName) throws java.rmi.RemoteException;

    /**
     * Löscht das ausgewählte Flugzeug in der Datenbank
     *
     * @param craftId
     * @param craftName
     * @param airId
     * @param typeOfAircraftId
     * @throws java.rmi.RemoteException
     */
    public void deleteAircraft(int craftId, String craftName, int airId, int typeOfAircraftId) throws java.rmi.RemoteException;

    /**
     * Löscht den ausgewählten Flugzeugtyp in der Datenbank
     *
     * @param craftTypeId
     * @param craftTypeName
     * @param seatId
     * @throws java.rmi.RemoteException
     */
    public void deleteTypeOfAircraft(int craftTypeId, String craftTypeName, int seatId) throws java.rmi.RemoteException;

    /**
     * Löscht einen Flug in der Datenbank
     *
     * @param flightId
     * @param timeOfDeparture
     * @param dayOfDeparture
     * @param timeOfArrival
     * @param dayOfArrival
     * @param departureAirportId
     * @param arrivalAirportId
     * @param airlineId
     * @throws java.rmi.RemoteException
     */
    public void deleteFlight(int flightId, String timeOfDeparture, String dayOfDeparture,
            String timeOfArrival, String dayOfArrival, String departureAirportId, String arrivalAirportId, int airlineId)
                throws java.rmi.RemoteException;

     /**
     * Löscht einen Flug in der Datenbank
     *
     * @param realizationId
     * @param dateOfDeparture
     * @param dateOfArrival
     * @param flightId
     * @param aircraftId
     * @throws java.rmi.RemoteException
     */
    public void deleteFlightRealization(int realizationId, Date dateOfDeparture, Date dateOfArrival, int flightId, int aircraftId)
            throws java.rmi.RemoteException;

    /**
     * Löscht den ausgewählten Passagier in der Datenbank
     *
     * @param passengerId
     * @param firstName
     * @param lastName
     * @param street
     * @param postcode
     * @param city
     * @throws java.rmi.RemoteException
     */
    public void deletePassenger(int passengerId, String firstName, String lastName, String street, int postcode, String city)
            throws java.rmi.RemoteException;

    /**
     * Löscht die ausgewählte Sitzstruktur in der Datenbank
     *
     * @param seatId
     * @param seatsPerRow
     * @param numberOfRows
     * @throws java.rmi.RemoteException
     */
    public void deleteSeat(int seatId, int seatsPerRow, int numberOfRows) throws java.rmi.RemoteException;

    /**
     * Löscht die ausgewählte Buchung in der Datenbank
     *
     * @param bookingId
     * @param passengerId
     * @param realizationId
     * @throws java.rmi.RemoteException
     */
    public void deleteBooking(int bookingId, int passengerId, int realizationId) throws java.rmi.RemoteException;

    /**
     * Löscht alle Buchungen des Passagiers
     * 
     * @param passengerId
     * @throws java.rmi.RemoteException
     */
    public void deleteAllBookingsFromPassenger(int passengerId) throws java.rmi.RemoteException;


    /*      -       getAll-Methoden     -       */

    
        /**
     * Gibt alle Flughäfen für die JTable aus
     *
     * @return Vector<Vector>
     * @throws java.rmi.RemoteException
     */
    public Vector<Vector> getAllAirportsForTable() throws java.rmi.RemoteException;

    /**
     * Gibt alle Flughäfen für die ComboBoxen aus
     *
     * @return Vector<Airport>
     * @throws java.rmi.RemoteException
     */
    public Vector<Airport> getAllAirportsForComboBox() throws java.rmi.RemoteException;

    /**
     * Gibt die Städtenamen sowie die internationalen Kürzel aller Flughäfen für die ComboBoxen aus
     *
     * @return Vector<String>
     * @throws java.rmi.RemoteException
     */
    public Vector<String> getAllAirportCitiesAndIdsForComboBox() throws java.rmi.RemoteException;

    /**
     * Gibt alle Fluglinien für die JTable aus
     *
     * @return Vector<Vector>
     * @throws java.rmi.RemoteException
     */
    public Vector<Vector> getAllAirlinesForTable() throws java.rmi.RemoteException;

    /**
     * Gibt alle Fluglinien für die ComboBox aus
     *
     * @return Vector<Airline>
     * @throws java.rmi.RemoteException
     */
    public Vector<Airline> getAllAirlinesForComboBox() throws java.rmi.RemoteException;

    /**
     * Gibt die Namen der Fluglinien für die ComboBoxen aus
     *
     * @return Vector<String>
     * @throws java.rmi.RemoteException
     */
    public Vector<String> getAllAirlineNamesForComboBox() throws java.rmi.RemoteException;
    
    /**
     * Gibt alle Flugzeuge für die JTable aus
     *
     * @return Vector<Vector>
     * @throws java.rmi.RemoteException
     */
    public Vector<Vector> getAllAircraftsForTable() throws java.rmi.RemoteException;

    /**
     * Gibt alle Flugzeuge für die ComboBox aus
     *
     * @return Vector<Aircraft>
     * @throws java.rmi.RemoteException
     */
    public Vector<Aircraft> getAllAircraftsForComboBox() throws java.rmi.RemoteException;

    /**
     * Gibt alle Flugzeugtypen für die JTable aus
     *
     * @return Vector<Vector>
     * @throws java.rmi.RemoteException
     */
    public Vector<Vector> getAllTypeOfAircraftsForTable() throws java.rmi.RemoteException;

    /**
     * Gibt alle Flugzeugtypen für die ComboBox aus
     *
     * @return Vector<TypeOfAircraft>
     * @throws java.rmi.RemoteException
     */
    public Vector<TypeOfAircraft> getAllTypeOfAircraftsForComboBox() throws java.rmi.RemoteException;

    /**
     * Gibt Informationen aller Flugzeugtypen für die ComboBox aus
     *
     * @return Vector<String>
     * @throws java.rmi.RemoteException
     */
    public Vector<String> getAllTypeOfAircraftInformationsForComboBox() throws java.rmi.RemoteException;

    /**
     * Gibt alle Flüge für die JTable aus
     *
     * @return Vector<Vector>
     * @throws java.rmi.RemoteException
     */
    public Vector<Vector> getAllFlightsForTable() throws java.rmi.RemoteException;

    /**
     * Gibt alle Flüge am Montag für die JTable aus
     *
     * @return Vector<Vector>
     * @throws java.rmi.RemoteException
     */
    public Vector<Vector> getAllFlightsOnMondayForTable() throws java.rmi.RemoteException;

    /**
     * Gibt alle Flüge am Dienstag für die JTable aus
     *
     * @return Vector<Vector>
     * @throws java.rmi.RemoteException
     */
    public Vector<Vector> getAllFlightsOnTuesdayForTable() throws java.rmi.RemoteException;

    /**
     * Gibt alle Flüge am Mittwoch für die JTable aus
     *
     * @return Vector<Vector>
     * @throws java.rmi.RemoteException
     */
    public Vector<Vector> getAllFlightsOnWednesdayForTable() throws java.rmi.RemoteException;

    /**
     * Gibt alle Flüge am Donnerstag für die JTable aus
     *
     * @return Vector<Vector>
     * @throws java.rmi.RemoteException
     */
    public Vector<Vector> getAllFlightsOnThursdayForTable() throws java.rmi.RemoteException;

    /**
     * Gibt alle Flüge am Freitag für die JTable aus
     *
     * @return Vector<Vector>
     * @throws java.rmi.RemoteException
     */
    public Vector<Vector> getAllFlightsOnFridayForTable() throws java.rmi.RemoteException;

    /**
     * Gibt alle Flüge am Samstag für die JTable aus
     *
     * @return Vector<Vector>
     * @throws java.rmi.RemoteException
     */
    public Vector<Vector> getAllFlightsOnSaturdayForTable() throws java.rmi.RemoteException;

    /**
     * Gibt alle Flüge am Sonntag für die JTable aus
     *
     * @return Vector<Vector>
     * @throws java.rmi.RemoteException
     */
    public Vector<Vector> getAllFlightsOnSundayForTable() throws java.rmi.RemoteException;
    
    /**
     * Gibt alle ausführenden Flüge und weitere relevante Daten für die JTable aus
     *
     * @return Vector<Vector>
     * @throws java.rmi.RemoteException
     */
    public Vector<Vector> getAllFlightRealizationsForTable() throws java.rmi.RemoteException;

    /**
     * Gibt alle ausführenden Flüge am Montag sowie weitere relevante Daten für die JTable aus
     *
     * @return Vector<Vector>
     * @throws java.rmi.RemoteException
     */
    public Vector<Vector> getAllFlightRealizationsOnMondayForTable() throws java.rmi.RemoteException;

    /**
     * Gibt alle ausführenden Flüge am Dienstag sowie weitere relevante Daten für die JTable aus
     *
     * @return Vector<Vector>
     * @throws java.rmi.RemoteException
     */
    public Vector<Vector> getAllFlightRealizationsOnTuesdayForTable() throws java.rmi.RemoteException;

    /**
     * Gibt alle ausführenden Flüge am Mittwoch sowie weitere relevante Daten für die JTable aus
     *
     * @return Vector<Vector>
     * @throws java.rmi.RemoteException
     */
    public Vector<Vector> getAllFlightRealizationsOnWednesdayForTable() throws java.rmi.RemoteException;

    /**
     * Gibt alle ausführenden Flüge am Donnerstag sowie weitere relevante Daten für die JTable aus
     *
     * @return Vector<Vector>
     * @throws java.rmi.RemoteException
     */
    public Vector<Vector> getAllFlightRealizationsOnThursdayForTable() throws java.rmi.RemoteException;

    /**
     * Gibt alle ausführenden Flüge am Freitag sowie weitere relevante Daten für die JTable aus
     *
     * @return Vector<Vector>
     * @throws java.rmi.RemoteException
     */
    public Vector<Vector> getAllFlightRealizationsOnFridayForTable() throws java.rmi.RemoteException;

    /**
     * Gibt alle ausführenden Flüge am Samstag sowie weitere relevante Daten für die JTable aus
     *
     * @return Vector<Vector>
     * @throws java.rmi.RemoteException
     */
    public Vector<Vector> getAllFlightRealizationsOnSaturdayForTable() throws java.rmi.RemoteException;

    /**
     * Gibt alle ausführenden Flüge am Sonntag sowie weitere relevante Daten für die JTable aus
     *
     * @return Vector<Vector>
     * @throws java.rmi.RemoteException
     */
    public Vector<Vector> getAllFlightRealizationsOnSundayForTable() throws java.rmi.RemoteException;

    /**
     * Gibt alle Flugdurchführungen für die ComboBox aus
     *
     * @return Vector<FlightRealization>
     * @throws java.rmi.RemoteException
     */
    public Vector<FlightRealization> getAllFlightRealizationsForComboBox() throws java.rmi.RemoteException;

    /**
     * Gibt Informationen zu allen Flugdurchführungen für die ComboBox zurück
     *
     * @return Vector<String>
     * @throws java.rmi.RemoteException
     */
    public Vector<String> getAllFlightRealizationInfosForComboBox() throws java.rmi.RemoteException;

    /**
     * Gibt alle Passagiere für die JTable aus
     *
     * @return Vector<Vector>
     * @throws java.rmi.RemoteException
     */
    public Vector<Vector> getAllPassengersForTable() throws java.rmi.RemoteException;

    /**
     * Gibt alle Passagiere deren Nachnamen zwischen A-E liegen für die JTable aus
     *
     * @return Vector<Vector>
     * @throws java.rmi.RemoteException
     */
    public Vector<Vector> getAllPassengersFromAtoEForTable() throws java.rmi.RemoteException;

    /**
     * Gibt alle Passagiere deren Nachnamen zwischen F-J liegen für die JTable aus
     *
     * @return Vector<Vector>
     * @throws java.rmi.RemoteException
     */
    public Vector<Vector> getAllPassengersFromFtoJForTable() throws java.rmi.RemoteException;

    /**
     * Gibt alle Passagiere deren Nachnamen zwischen K-O liegen für die JTable aus
     *
     * @return Vector<Vector>
     * @throws java.rmi.RemoteException
     */
    public Vector<Vector> getAllPassengersFromKtoOForTable() throws java.rmi.RemoteException;

    /**
     * Gibt alle Passagiere deren Nachnamen zwischen P-T liegen für die JTable aus
     *
     * @return Vector<Vector>
     * @throws java.rmi.RemoteException
     */
    public Vector<Vector> getAllPassengersFromPtoTForTable() throws java.rmi.RemoteException;

    /**
     * Gibt alle Passagiere deren Nachnamen zwischen U-Z liegen für die JTable aus
     *
     * @return Vector<Vector>
     * @throws java.rmi.RemoteException
     */
    public Vector<Vector> getAllPassengersFromUtoZForTable() throws java.rmi.RemoteException;

    /**
     * Gibt alle Passagiere für die ComboBox aus
     *
     * @return Vector<Passenger>
     * @throws java.rmi.RemoteException
     */
    public Vector<Passenger> getAllPassengersForComboBox() throws java.rmi.RemoteException;
            
    /**
     * Gibt alle Sitzstrukturen für die JTable aus
     *
     * @return Vector<Vector>
     * @throws java.rmi.RemoteException
     */
    public Vector<Vector> getAllSeatsForTable() throws java.rmi.RemoteException;

    /**
     * Gibt alle Sitzstrukturen für die ComboBox aus
     *
     * @return Vector<Seat>
     * @throws java.rmi.RemoteException
     */
    public Vector<Seat> getAllSeatsForComboBox() throws java.rmi.RemoteException;

    /**
     * Gibt Informationen über alle Sitzstrukturen für die ComboBox aus
     *
     * @return Vector<String>
     * @throws java.rmi.RemoteException
     */
    public Vector<String> getAllSeatInformationForComboBox() throws java.rmi.RemoteException;

    /**
     * Gibt alle Buchungen für die JTable aus
     *
     * @return Vector<Vector>
     * @throws java.rmi.RemoteException
     */
    public Vector<Vector> getAllBookingsForTable() throws java.rmi.RemoteException;

    /**
     * Gibt alle Buchungen einer Flugdurchführung (FlightRealization) für die JTable aus
     *
     * @param realizationId (Nr. der Flugdurchführung)
     * @return Vector<Vector>
     * @throws java.rmi.RemoteException
     */
    public Vector<Vector> getAllBookingsByRealizationIdForTable(int realizationId) throws java.rmi.RemoteException;

    /**
     * Gibt alle Passagiere aus, die eingecheckt haben
     *
     * @return Vector<Booking>
     * @throws java.rmi.RemoteException
     */
    public Vector<Booking> findAllBookingsByAlreadyCheckedIn() throws java.rmi.RemoteException;

    /**
     * Gibt alle Flugzeuge für die ComboBox zurück die im entsprechenden Zeitraum zur Verfügung stehen.
     *
     * @param dateOfDeparture
     * @param dateOfArrival
     * @param airlineId
     * @return Vector<Aircraft> mit allen verfügbaren Flugzeugen
     * @throws java.rmi.RemoteException
     */
    public Vector<Aircraft> getAllAircraftsByAvailabilityForComboBox(Date dateOfDeparture, Date dateOfArrival, int airlineId)
            throws java.rmi.RemoteException;


    /*      -       getBy-Methoden     -       */


    /**
     * Gibt den Flughafen anhand des Namens zurück
     * @param portName
     * @return Einen Flughafen
     * @throws java.rmi.RemoteException
     */
    public Airport getAirportByName(String portName) throws java.rmi.RemoteException;

    /**
     * Gibt den Flughafen anhand der Id zurück
     * @param id
     * @return Einen Flughafen
     * @throws java.rmi.RemoteException
     */
    public Airport getAirportById(String id) throws java.rmi.RemoteException;

    /**
     * Gibt die Fluglinie anhand des Namens zurück
     * @param name
     * @return Eine Fluglinie
     * @throws java.rmi.RemoteException
     */
    public Airline getAirlineByName(String name) throws java.rmi.RemoteException;

    /**
     * Gibt die Fluglinie anhand der Id zurück
     * @param id
     * @return Eine Fluglinie
     * @throws java.rmi.RemoteException
     */
    public Airline getAirlineById(int id) throws java.rmi.RemoteException;

    /**
     * Gibt ein Flugzeug anhand des Namens zurück
     * @param name
     * @return Ein Flugzeug
     * @throws java.rmi.RemoteException
     */
    public Aircraft getAircraftByName(String name) throws java.rmi.RemoteException;

    /**
     * Gibt ein Flugzeug anhand der Id zurück
     * @param id
     * @return Ein Flugzeug
     * @throws java.rmi.RemoteException
     */
    public Aircraft getAircraftById(int id) throws java.rmi.RemoteException;

    /**
     * Gibt einen Flugzeugtyp anhand des Namens zurück
     * @param type
     * @return Ein Flugzeugtyp
     * @throws java.rmi.RemoteException
     */
    public TypeOfAircraft getTypeOfAircraftByName(String type) throws java.rmi.RemoteException;

    /**
     * Gibt ein Flugzeug anhand der Id zurück
     * @param id
     * @return
     * @throws java.rmi.RemoteException
     */
    public TypeOfAircraft getTypeOfAircraftById(int id) throws java.rmi.RemoteException;

    /**
     * Gibt einen Flug anhand der Id zurück
     * @param id
     * @return Ein Flug
     * @throws java.rmi.RemoteException
     */
    public Flight getFlightById(int id) throws java.rmi.RemoteException;

    /**
     * Gibt eine Flugdurchführung anhand der Id zurück
     * @param id
     * @return Eine Flugdurchführung
     * @throws java.rmi.RemoteException
     */
    public FlightRealization getFlightRealizationById(int id) throws java.rmi.RemoteException;

    /**
     * Gibt einen Passagier anhand der Id zurück
     * @param id
     * @return Ein Passagier
     * @throws java.rmi.RemoteException
     */
    public Passenger getPassengerById(int id) throws java.rmi.RemoteException;

    /**
     * Gibt einen Passagier anhand des Namens zurück
     * @param firstName
     * @param lastName
     * @return Ein Passagier
     * @throws java.rmi.RemoteException
     */
    public Vector<Passenger> getPassengerByName(String firstName, String lastName) throws java.rmi.RemoteException;

    /**
     * Gibt eine Sitzstruktor anhand der Id zurück
     *
     * @param id (Id der Sitzstruktur)
     * @return Seat-Objekt
     * @throws java.rmi.RemoteException
     */
    public Seat getSeatById(int id) throws java.rmi.RemoteException;
    
    /**
     * Gibt die Buchung anhand der Id zurück
     * @param id
     * @return Eine Buchung
     * @throws java.rmi.RemoteException
     */
    public Booking getBookingById(int id) throws java.rmi.RemoteException;

    /**
     * Gibt eine bestimmte Buchung zurück
     * @param id
     * @return Eine bestimmte Buchung bei der Flugdurchführung
     * @throws java.rmi.RemoteException
     */
    public Booking getBookingByRealizationId(int id) throws java.rmi.RemoteException;

    /**
     * Gibt die Referenz eines ReportGenerators zurück
     *
     * @return reportGenerator
     * @throws RemoteException
     */
    public ReportGenerator getReportGenerator() throws java.rmi.RemoteException;

    /**
     * Buchungen pro Passagier anhand der Airline und der Zeit finden
     * @param passengerId
     * @param airlineId
     * @param startDate
     * @param endDate
     * @return Eine bestimmte Buchung
     * @throws java.rmi.RemoteException
     */
    public Vector<Booking> findBookingsByPassengerByAirlineAndByTimeframe(int passengerId, int airlineId, Date startDate, Date endDate) throws java.rmi.RemoteException;

    /**
     * Anzahl der Buchungen für eine Flugdurchführung
     *
     * @param realizationId, Nr. der Flugdurchführung
     * @return Integerwert mit der Anzahl der Buchungen für eine bestimmte Flugdurchführung
     * @throws java.rmi.RemoteException
     */
    public int findNumberOfBookingsForRealizationId(int realizationId) throws java.rmi.RemoteException;

    /**
     * Gibt die Gesamtsitzplatzanzahl der ausgewählten FlightRealization zurück
     *
     * @param realizationId (Nr. der Flugdurchführung
     * @return numberOfAllSeats (Gesamtsitzplatzanzahl)
     * @throws java.rmi.RemoteException
     */
    public int findNumberOfAllSeatsForRealizationId(int realizationId) throws java.rmi.RemoteException;
    
    /**
     * Check-In für eine bestimmte Buchung durchführen
     * @param b
     * @return Check-In
     * @throws java.rmi.RemoteException
     */
    public boolean executeCheckInForSpecificBooking(Booking b) throws java.rmi.RemoteException;


    /*      -       SetCurrentObject-Methoden     -       */

    /**
     * Aktuell ausgewähltes Aircraft-Objekt wird in Variable zwischengespeichert
     *
     * @param currentAircraft (Aktuelles Flugzeugobjekt)
     * @throws java.rmi.RemoteException
     */
    public void setCurrentAircraft(Aircraft currentAircraft) throws java.rmi.RemoteException;

    /**
     * Aktuell ausgewähltes Airline-Objekt wird in Variable zwischengespeichert
     *
     * @param currentAirline (Aktuelles Fluglinienobjekt)
     * @throws java.rmi.RemoteException
     */
    public void setCurrentAirline(Airline currentAirline) throws java.rmi.RemoteException;

    /**
     * Aktuell ausgewähltes Airport-Objekt wird in Variable zwischengespeichert
     *
     * @param currentAirport (Aktuelles Flughafenobjekt)
     * @throws java.rmi.RemoteException
     */
    public void setCurrentAirport(Airport currentAirport) throws java.rmi.RemoteException;

    /**
     * Aktuell ausgewähltes Booking-Objekt wird in Variable zwischengespeichert
     *
     * @param currentBooking (Aktuelles Buchungsobjekt)
     * @throws java.rmi.RemoteException
     */
    public void setCurrentBooking(Booking currentBooking) throws java.rmi.RemoteException;

    /**
     * Aktuell ausgewähltes Flight-Objekt wird in Variable zwischengespeichert
     *
     * @param currentFlight (Aktuelles Flugobjekt)
     * @throws java.rmi.RemoteException
     */
    public void setCurrentFlight(Flight currentFlight) throws java.rmi.RemoteException;

    /**
     * Aktuell ausgewähltes FlightRealization-Objekt wird in Variable zwischengespeichert
     *
     * @param currentFlightRealization (Aktuelles Flugdurchführungsobjekt)
     * @throws java.rmi.RemoteException
     */
    public void setCurrentFlightRealization(FlightRealization currentFlightRealization) throws java.rmi.RemoteException;

    /**
     * Aktuell ausgewähltes Passenger-Objekt wird in Variable zwischengespeichert
     *
     * @param currentPassenger (Aktuelles Passagierobjekt)
     * @throws java.rmi.RemoteException
     */
    public void setCurrentPassenger(Passenger currentPassenger) throws java.rmi.RemoteException;

    /**
     * Aktuell ausgewähltes Seat-Objekt wird in Variable zwischengespeichert
     *
     * @param currentSeat (Aktuelles Sitzstrukturobjekt)
     * @throws java.rmi.RemoteException
     */
    public void setCurrentSeat(Seat currentSeat) throws java.rmi.RemoteException;

    /**
     * Aktuell ausgewähltes TypeOfAircraft-Objekt wird in Variable zwischengespeichert
     *
     * @param currentTypeOfAircraft (Aktuelles Flugzeugtypobjekt)
     * @throws java.rmi.RemoteException
     */
    public void setCurrentTypeOfAircraft(TypeOfAircraft currentTypeOfAircraft) throws java.rmi.RemoteException;


    /*      -       GetCurrentObject-Methoden     -       */

    /**
     * Gibt das aktuelle Aircraft-Objekt zurück
     *
     * @return currentAircraft (Aktuelles Flugzeugobjekt)
     * @throws java.rmi.RemoteException
     */
    public Aircraft getCurrentAircraft() throws java.rmi.RemoteException;

    /**
     * Gibt das aktuelle Airline-Objekt zurück
     *
     * @return currentAirline (Aktuelles Fluglinienobjekt)
     * @throws java.rmi.RemoteException
     */
    public Airline getCurrentAirline() throws java.rmi.RemoteException;

    /**
     * Gibt das aktuelle Airport-Objekt zurück
     *
     * @return currentAirport (Aktuelles Flughafenobjekt)
     * @throws java.rmi.RemoteException
     */
    public Airport getCurrentAirport() throws java.rmi.RemoteException;

    /**
     * Gibt das aktuelle Booking-Objekt zurück
     *
     * @return currentBooking (Aktuelles Buchungsobjekt)
     * @throws java.rmi.RemoteException
     */
    public Booking getCurrentBooking() throws java.rmi.RemoteException;

    /**
     * Gibt das aktuelle Flight-Objekt zurück
     *
     * @return currentFlight (Aktuelles Flugobjekt)
     * @throws java.rmi.RemoteException
     */
    public Flight getCurrentFlight() throws java.rmi.RemoteException;

    /**
     * Gibt das aktuelle FlightRealization-Objekt zurück
     *
     * @return currentFlightRealization (Aktuelles Flugdurchführungsobjekt)
     * @throws java.rmi.RemoteException
     */
    public FlightRealization getCurrentFlightRealization() throws java.rmi.RemoteException;

    /**
     * Gibt das aktuelle Passenger-Objekt zurück
     *
     * @return currentPassenger (Aktuelles Passagierobjekt)
     * @throws java.rmi.RemoteException
     */
    public Passenger getCurrentPassenger() throws java.rmi.RemoteException;

    /**
     * Gibt das aktuelle Seat-Objekt zurück
     *
     * @return currentSeat (Aktuelles Sitzstrukturobjekt)
     * @throws java.rmi.RemoteException
     */
    public Seat getCurrentSeat() throws java.rmi.RemoteException;

    /**
     * Gibt das aktuelle TypeOfAircraft-Objekt zurück
     *
     * @return currentTypeOfAircraft (Aktuelles Flugzeugtypobjekt)
     * @throws java.rmi.RemoteException
     */
    public TypeOfAircraft getCurrentTypeOfAircraft() throws java.rmi.RemoteException;

}
